package com.mazewei.dev.service;

import com.mazewei.dev.dao.ClassDao;
import com.mazewei.dev.entity.Class;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 班级匹配服务
 * 负责处理班级名称的匹配、格式化和编号生成
 */
@Service
public class ClassMatchingService {
    
    private static final Logger logger = LoggerFactory.getLogger(ClassMatchingService.class);
    
    @Autowired
    private ClassDao classDao;
    
    @Autowired
    private GradeExtractionService gradeExtractionService;
    
    /**
     * 获取班级编号（从数据库查询）
     * @param className 班级名称
     * @return 班级编号
     */
    public String getClassCode(String className) {
        if (className == null || className.trim().isEmpty()) {
            logger.warn("[班级匹配失败] 班级名称为空");
            return "";
        }
        
        logger.info("[班级匹配开始] 班级名称: {}", className);
        
        try {
            // 步骤1: 尝试直接匹配原始班级名称
            logger.debug("[步骤1] 尝试原始班级名称查找: {}", className);
            Class clazz = classDao.findByName(className);
            if (clazz != null && clazz.getClassNum() != null) {
                logger.info("[班级匹配成功] 原始名称匹配 - 班级: {} -> 编号: {}", className, clazz.getClassNum());
                return clazz.getClassNum();
            }
            
            // 步骤2: 尝试使用convertClassFormat转换格式后匹配（处理"一（9）班"格式）
            String convertedClassName = convertClassFormat(className);
            if (!convertedClassName.equals(className)) {
                logger.debug("[步骤2] 尝试转换格式班级名称查找: {} -> {}", className, convertedClassName);
                clazz = classDao.findByName(convertedClassName);
                if (clazz != null && clazz.getClassNum() != null) {
                    logger.info("[班级匹配成功] 转换格式名称匹配 - 班级: {} -> 编号: {}", convertedClassName, clazz.getClassNum());
                    return clazz.getClassNum();
                }
            }
            
            // 步骤3: 尝试格式化后的班级名称（如：一年1班 -> 一年级1班）
            String formattedClassName = formatClassNameForDatabase(className);
            if (!formattedClassName.equals(className)) {
                logger.debug("[步骤3] 尝试格式化班级名称查找: {} -> {}", className, formattedClassName);
                clazz = classDao.findByName(formattedClassName);
                if (clazz != null && clazz.getClassNum() != null) {
                    logger.info("[班级匹配成功] 格式化名称匹配 - 班级: {} -> 编号: {}", formattedClassName, clazz.getClassNum());
                    return clazz.getClassNum();
                }
            }
            
            // 步骤4: 尝试其他可能的格式变换
            List<String> possibleNames = generatePossibleClassNames(className);
            for (String possibleName : possibleNames) {
                logger.debug("[步骤4] 尝试可能的班级名称: {}", possibleName);
                clazz = classDao.findByName(possibleName);
                if (clazz != null && clazz.getClassNum() != null) {
                    logger.info("[班级匹配成功] 可能名称匹配 - 班级: {} -> 编号: {}", possibleName, clazz.getClassNum());
                    return clazz.getClassNum();
                }
            }
            
            // 步骤5: 如果所有匹配都失败，返回空字符串
            logger.warn("[班级匹配失败] 未找到班级: {}", className);
            return "";
            
        } catch (Exception e) {
            logger.error("[班级匹配异常] 查询班级编号时发生错误: {}", className, e);
            return "";
        }
    }
    
    /**
     * 转换班级格式：一（1）班 -> 一年1班，七（1）班 -> 七年1班，七年级1班 -> 七年1班
     * @param className 原始班级名称
     * @return 转换后的班级名称
     */
    public String convertClassFormat(String className) {
        return convertClassFormat(className, "primary");
    }
    
    /**
     * 转换班级格式（支持学部选择）：一（1）班 -> 一年1班，七（1）班 -> 七年1班，七年级1班 -> 七年1班
     * @param className 原始班级名称
     * @param schoolSection 学部选择（primary=小学部，middle=初中部）
     * @return 转换后的班级名称
     */
    public String convertClassFormat(String className, String schoolSection) {
        if (className == null || className.trim().isEmpty()) {
            return className;
        }
        
        try {
            // 处理已经是"七年级1班"格式的班级名称，转换为"七年1班"（去掉"级"字）
            String gradeClassPattern = "([一二三四五六七八九十]+)年级(\\d+)班";
            if (className.matches(gradeClassPattern)) {
                String grade = className.replaceAll(gradeClassPattern, "$1");
                String classNumber = className.replaceAll(gradeClassPattern, "$2");
                String result = grade + "年" + classNumber + "班";
                logger.debug("[班级格式转换] {} -> {}", className, result);
                return result;
            }
            
            // 处理"七年级12班"这样的格式，支持两位数班级号
            String gradeClassPattern2 = "([一二三四五六七八九十]+)年级(\\d{1,2})班";
            if (className.matches(gradeClassPattern2)) {
                String grade = className.replaceAll(gradeClassPattern2, "$1");
                String classNumber = className.replaceAll(gradeClassPattern2, "$2");
                String result = grade + "年" + classNumber + "班";
                logger.debug("[班级格式转换] {} -> {}", className, result);
                return result;
            }
            
            // 匹配格式：一（1）班、二（2）班、七（1）班、八（2）班、九（3）班等，兼容中文括号和英文括号的混合使用
            String pattern = "([一二三四五六七八九十]+)[（(](\\d+)[）)]班";
            if (className.matches(pattern)) {
                String grade = className.replaceAll(pattern, "$1");
                String classNumber = className.replaceAll(pattern, "$2");
                String result = grade + "年" + classNumber + "班";
                logger.debug("[班级格式转换] {} -> {}", className, result);
                return result;
            }
            
            // 如果没有匹配到任何模式，返回原始班级名称
            logger.debug("[班级格式转换] 未匹配到任何模式，保持原样: {}", className);
            return className;
            
        } catch (Exception e) {
            logger.error("[班级格式转换异常] 转换班级格式时发生错误: {}", className, e);
            return className; // 异常情况下返回原始名称
        }
    }
    
    /**
     * 格式化班级名称以匹配数据库中的格式
     * @param className 原始班级名称
     * @return 格式化后的班级名称
     */
    private String formatClassNameForDatabase(String className) {
        if (className == null || className.trim().isEmpty()) {
            return className;
        }
        
        try {
            // 将"一年1班"格式转换为"一年级1班"格式
            String pattern = "([一二三四五六七八九十]+)年(\\d+)班";
            if (className.matches(pattern)) {
                String grade = className.replaceAll(pattern, "$1");
                String classNumber = className.replaceAll(pattern, "$2");
                String result = grade + "年级" + classNumber + "班";
                logger.debug("[班级格式化] {} -> {}", className, result);
                return result;
            }
            
            return className;
            
        } catch (Exception e) {
            logger.error("[班级格式化异常] 格式化班级名称时发生错误: {}", className, e);
            return className;
        }
    }
    
    /**
     * 生成可能的班级名称变体
     * @param className 原始班级名称
     * @return 可能的班级名称列表
     */
    private List<String> generatePossibleClassNames(String className) {
        List<String> possibleNames = new ArrayList<>();
        
        if (className == null || className.trim().isEmpty()) {
            return possibleNames;
        }
        
        String originalClass = className.trim();
        
        // 尝试不同的格式变体
        
        // 1. 如果是"一年1班"格式，尝试"一（1）班"格式
        String pattern1 = "([一二三四五六七八九十]+)年(\\d+)班";
        if (originalClass.matches(pattern1)) {
            String grade = originalClass.replaceAll(pattern1, "$1");
            String classNumber = originalClass.replaceAll(pattern1, "$2");
            possibleNames.add(grade + "（" + classNumber + "）班");
            possibleNames.add(grade + "(" + classNumber + ")班");
        }
        
        // 2. 如果是"一（1）班"格式，尝试"一年1班"格式
        String pattern2 = "([一二三四五六七八九十]+)[（(](\\d+)[）)]班";
        if (originalClass.matches(pattern2)) {
            String grade = originalClass.replaceAll(pattern2, "$1");
            String classNumber = originalClass.replaceAll(pattern2, "$2");
            possibleNames.add(grade + "年" + classNumber + "班");
            possibleNames.add(grade + "年级" + classNumber + "班");
        }
        
        // 3. 尝试添加或移除"级"字
        if (originalClass.contains("年级")) {
            possibleNames.add(originalClass.replace("年级", "年"));
        } else if (originalClass.contains("年") && !originalClass.contains("年级")) {
            possibleNames.add(originalClass.replace("年", "年级"));
        }
        
        // 4. 尝试不同的括号格式
        if (originalClass.contains("（") && originalClass.contains("）")) {
            possibleNames.add(originalClass.replace("（", "(").replace("）", ")"));
        } else if (originalClass.contains("(") && originalClass.contains(")")) {
            possibleNames.add(originalClass.replace("(", "（").replace(")", "）"));
        }
        
        // 去除重复项
        return possibleNames.stream().distinct().collect(java.util.stream.Collectors.toList());
    }
    
    /**
     * 生成默认班级编号
     * 当数据库中找不到对应班级时，基于班级名称生成一个默认编号
     */
    private String generateDefaultClassCode(String className) {
        if (className == null || className.trim().isEmpty()) {
            return "DEFAULT_CLASS_000";
        }
        
        // 按照数据库标准生成班级编号：年份+班级序号（如2024001表示一年1班）
        // 数据库格式分析：
        // 一年级：2024001-2024010
        // 二年级：2023001-2023008  
        // 三年级：2022001-2022007
        // 四年级：2021001-2021006
        // 五年级：2020001-2020009
        // 六年级：2019001-2019006
        // 七年级：2018001-2018012
        // 八年级：2017001-2017008
        // 九年级：2016001-2016005
        
        // 提取年级信息
        String gradeNumber = gradeExtractionService.extractGradeNumber(className);
        int grade = Integer.parseInt(gradeNumber);
        
        // 计算年份：当前年份减去年级数再加1
        // 例如：一年级(1) = 2024, 二年级(2) = 2023, 以此类推
        int currentYear = 2024; // 可以根据实际情况调整为动态获取当前年份
        int classYear = currentYear - grade + 1;
        
        // 提取班级号
        String classNumber = extractClassNumber(className);
        int classNum = 1; // 默认班级号
        if (classNumber != null && !classNumber.isEmpty()) {
            try {
                classNum = Integer.parseInt(classNumber);
            } catch (NumberFormatException e) {
                logger.warn("[班级号解析失败] 班级名称: {}, 使用默认班级号1", className);
            }
        }
        
        // 生成标准格式的班级编号：年份 + 三位班级序号
        String classCode = String.format("%d%03d", classYear, classNum);
        
        logger.info("[生成班级编号] 班级名称: {} -> 编号: {} (年份: {}, 班级号: {})", 
                   className, classCode, classYear, classNum);
        
        return classCode;
    }
    
    /**
     * 从班级名称中提取班级号
     * @param className 班级名称
     * @return 班级号
     */
    private String extractClassNumber(String className) {
        if (className == null || className.trim().isEmpty()) {
            return null;
        }
        
        try {
            // 匹配"一年1班"、"一（1）班"等格式中的数字
            String pattern = ".*[年（(](\\d+)[班）)].*";
            if (className.matches(pattern)) {
                return className.replaceAll(pattern, "$1");
            }
            
            // 如果没有匹配到，尝试提取所有数字
            String numbers = className.replaceAll("[^\\d]", "");
            if (!numbers.isEmpty()) {
                return numbers;
            }
            
        } catch (Exception e) {
            logger.warn("[班级号提取失败] 班级名称: {}, 错误: {}", className, e.getMessage());
        }
        
        return null;
    }
}